Mac Power 1997 December/MACPOWER-1997-12.ISO.7z/MACPOWER-1997-12.ISO/AMUG/PROGRAMMING/Raven 1.2 Examples.sit/Raven 1.2 Examples/Quill/Source/(Unused)/ResourceMap.cpp

C/C++ Source or Header | 1997-08-07 | 16KB | 647 lines

/*
 *  File:       ResourceMap.cpp
 *  Summary:       A class that knows how to manage resources of a specified type. The
 *                resource data is kept in memory so this class is unsuitable for large
 *                resources.
 *  Written by: Jesse Jones
 *
 *  Copyright ｩ 1996 Jesse Jones.
 *    For conditions of distribution and use, see copyright notice in ZTypes.h
 *
 *  Change History (most recent first):
 *
 *         <->     8/15/96    JDJ        Created
 */

#include "ResourceMap.h"

#include <Map.h>

#include <ZDragSession.h>
#include <ZExceptions.h>
#include <ZHandleStream.h>
#include <ZLocker.h>
#include <ZResUtils.h>
#include <ZStream.h>
#include <ZStringUtils.h>


// ===================================================================================
//    struct SResourceMapMessage
// ===================================================================================

//---------------------------------------------------------------
//
// SResourceMapMessage::SResourceMapMessage
//
//---------------------------------------------------------------
SResourceMapMessage::SResourceMapMessage(CResourceMap* rMap, ResID id, long mesg)
{
    ASSERT(rMap != nil);

    rsrcMap = rMap;

    if (mesg != kDeletingResources)
        oldRsrc = newRsrc = rsrcMap->GetResource(id);

    message = mesg;
}

#pragma mark -

//---------------------------------------------------------------
//
// SResource::SResource
//
//---------------------------------------------------------------
SResource::SResource(const TDragSession& session, ItemReference item, FlavorType flavor)
{
    THandle data = session.GetData(item, flavor);
    TInHandleStream stream(data);
        stream >> *this;
}


//---------------------------------------------------------------
//
// operator>> (SResource)
//
//---------------------------------------------------------------
TInStream& operator>>(TInStream& stream, SResource& value)
{
    Handle hand = value.data;

    stream >> value.id >> value.name >> hand;

    return stream;
}


//---------------------------------------------------------------
//
// operator<< (SResource)
//
//---------------------------------------------------------------
TOutStream& operator<<(TOutStream& stream, const SResource& value)
{
    stream << value.id << value.name << value.data;

    return stream;
}


//---------------------------------------------------------------
//
// SResource::AddData
//
//---------------------------------------------------------------
void SResource::AddData(TDragSession& session, ItemReference item, FlavorType flavor, FlavorFlags flags) const
{
    THandle bits;

    {
    TOutHandleStream stream(bits);
        stream << *this;
    }

    {
    TLocker lock(bits);
        session.AddData(item, flavor, bits.GetPtr(), bits.GetSize(), flags);
    }
}

#pragma mark -

// ===================================================================================
//    class CResourceMap::const_iterator
// ===================================================================================

class MapIterator : public CResourceMap::ResourceMap::const_iterator {

public:
    MapIterator()     {}

    MapIterator(const CResourceMap::ResourceMap::const_iterator& iter) : CResourceMap::ResourceMap::const_iterator(iter) {}

    MapIterator(CResourceMap::ResourceMap* resources) : CResourceMap::ResourceMap::const_iterator(resources->begin()) {}

    MapIterator(CResourceMap::ResourceMap* resources, int dummy) : CResourceMap::ResourceMap::const_iterator(resources->end()) {}
};


//---------------------------------------------------------------
//
// CResourceMap::const_iterator::~const_iterator
//
//---------------------------------------------------------------
CResourceMap::const_iterator::~const_iterator()
{
    delete mIter;
}


//---------------------------------------------------------------
//
// CResourceMap::const_iterator::const_iterator (MapIterator)
//
//---------------------------------------------------------------
CResourceMap::const_iterator::const_iterator(const MapIterator& iter)
{
    mIter = new MapIterator(iter);
}


//---------------------------------------------------------------
//
// CResourceMap::const_iterator::const_iterator (CResourceMap*)
//
//---------------------------------------------------------------
CResourceMap::const_iterator::const_iterator(CResourceMap* rsrcMap)
{
    ASSERT(rsrcMap != nil);

    mIter = new MapIterator(rsrcMap->mResources->begin());
}


//---------------------------------------------------------------
//
// CResourceMap::const_iterator::const_iterator (const_iterator)
//
//---------------------------------------------------------------
CResourceMap::const_iterator::const_iterator(const const_iterator& rhs)
{
    mIter = new MapIterator(*(rhs.mIter));
}


//---------------------------------------------------------------
//
// CResourceMap::const_iterator::operator=
//
//---------------------------------------------------------------
CResourceMap::const_iterator& CResourceMap::const_iterator::operator=(const const_iterator& rhs)
{
    if (*mIter != *(rhs.mIter)) {
        MapIterator* temp = new MapIterator(*(rhs.mIter));

        delete mIter;
        mIter = temp;
    }

    return *this;
}


//---------------------------------------------------------------
//
// CResourceMap::const_iterator::operator==
//
//---------------------------------------------------------------
bool CResourceMap::const_iterator::operator==(const const_iterator& rhs) const
{
    return *mIter == *(rhs.mIter);
}


//---------------------------------------------------------------
//
// CResourceMap::const_iterator::operator*
//
//---------------------------------------------------------------
SResource CResourceMap::const_iterator::operator*() const
{
    const ResourceEntry& entry = **mIter;

    return SResource(entry.first, entry.second.name, entry.second.hand);
}


//---------------------------------------------------------------
//
// CResourceMap::const_iterator::operator++ ()
//
//---------------------------------------------------------------
CResourceMap::const_iterator& CResourceMap::const_iterator::operator++()
{
    (*mIter)++;

    return *this;
}


//---------------------------------------------------------------
//
// CResourceMap::const_iterator::operator++ (int)
//
//---------------------------------------------------------------
CResourceMap::const_iterator CResourceMap::const_iterator::operator++(int)
{
     CResourceMap::const_iterator temp = *this;

     ++*this;

     return temp;
}

#pragma mark -

// ===================================================================================
//    class CResourceMap
// ===================================================================================

//---------------------------------------------------------------
//
// CResourceMap::~CResourceMap
//
//---------------------------------------------------------------
CResourceMap::~CResourceMap()
{
    delete mResources;
}


//---------------------------------------------------------------
//
// CResourceMap::CResourceMap
//
//---------------------------------------------------------------
CResourceMap::CResourceMap(ResType type)
{
    ASSERT(type != '????');

    mType = type;
    mResources = new ResourceMap;
}


//---------------------------------------------------------------
//
// CResourceMap::ReadResources
//
//---------------------------------------------------------------
void CResourceMap::ReadResources()
{
    // Zap any old resources that may be hanging around
    if (mResources->size() > 0)
        this->Broadcast(SResourceMapMessage(this, 0, kDeletingResources));
    mResources->erase(mResources->begin(), mResources->end());

    // and read in the new resources.
    short numViews = ::Count1Resources(mType);
    for (short index = 1; index <= numViews; index++) {
        Handle hand = ::Get1IndResource(mType, index);
        ThrowIfResFail(hand);

        ResID   id;
        ResType type;
        Str255  name;
        ::GetResInfo(hand, &id, &type, name);
        ThrowIfResError();

        this->AddResource(SResource(id, PStrToStr(name), hand));
    }
}


//---------------------------------------------------------------
//
// CResourceMap::WriteResources
//
// ･･･ﾊrewrite this so that an error while writing the new data
// ･･･ﾊout doesn't trash all of the old data
//
//---------------------------------------------------------------
void CResourceMap::WriteResources()
{
    // Out with the old...
    Delete1Resource(mType);

    // and in with the new.
    ResourceMap::iterator iter = mResources->begin();
    while (iter != mResources->end()) {
        ResourceEntry& entry = *iter++;
        ResID id = entry.first;
        SResourceData& data = entry.second;

        long size = data.hand.GetSize();

        Handle rsrc = ::NewHandle(size);
        ThrowIfMemFail(rsrc);

        ::BlockMoveData(data.hand.GetUnsafePtr(), *rsrc, size);
        ::AddResource(rsrc, mType, id, StrToPStr(data.name));
        ThrowIfResError();

        ::ReleaseResource(rsrc);

        data.dirty = false;
        this->Broadcast(SResourceMapMessage(this, id, kSavedResource));
    }
}


//---------------------------------------------------------------
//
// CResourceMap::GetNumResources
//
//---------------------------------------------------------------
long CResourceMap::GetNumResources() const
{
    return mResources->size();
}


//---------------------------------------------------------------
//
// CResourceMap::GetLastResourceID
//
//---------------------------------------------------------------
ResID CResourceMap::GetLastResourceID() const
{
    ResID lastID = 255;

    if (mResources->size() > 0) {
        ResourceMap::reverse_iterator iter = mResources->rbegin();

        const ResourceEntry& entry = *iter++;
        lastID = entry.first;
    }

    return lastID;
}


//---------------------------------------------------------------
//
// CResourceMap::GetResourceName
//
//---------------------------------------------------------------
string CResourceMap::GetResourceName(ResID id) const
{
    ASSERT(mResources->count(id) == 1);

    const SResourceData& data = mResources->operator[](id);

    return data.name;
}


//---------------------------------------------------------------
//
// CResourceMap::GetResourceData
//
//---------------------------------------------------------------
THandle CResourceMap::GetResourceData(ResID id) const
{
    ASSERT(mResources->count(id) == 1);

    const SResourceData& data = mResources->operator[](id);

    return data.hand;
}


//---------------------------------------------------------------
//
// CResourceMap::GetResource
//
//---------------------------------------------------------------
SResource CResourceMap::GetResource(ResID id) const
{
    ASSERT(mResources->count(id) == 1);

    const SResourceData& data = mResources->operator[](id);

    return SResource(id, data.name, data.hand);
}


//---------------------------------------------------------------
//
// CResourceMap::IsDirty ()
//
//---------------------------------------------------------------
bool CResourceMap::IsDirty() const
{
    bool dirty = false;

    ResourceMap::const_iterator iter = mResources->begin();
    while (iter != mResources->end() && !dirty) {
        const ResourceEntry& entry = *iter++;
        const SResourceData& data = entry.second;

        dirty = data.dirty;
    }

    return dirty;
}


//---------------------------------------------------------------
//
// CResourceMap::IsDirty (ResID)
//
//---------------------------------------------------------------
bool CResourceMap::IsDirty(ResID id) const
{
    ASSERT(mResources->count(id) == 1);

    const SResourceData& data = mResources->operator[](id);

    return data.dirty;
}


//---------------------------------------------------------------
//
// CResourceMap::ClearDirty ()
//
//---------------------------------------------------------------
void CResourceMap::ClearDirty()
{
    ResourceMap::iterator iter = mResources->begin();
    while (iter != mResources->end()) {
        ResourceEntry& entry = *iter++;
        SResourceData& data = entry.second;

        data.dirty = false;
    }
}


//---------------------------------------------------------------
//
// CResourceMap::ClearDirty (ResID)
//
//---------------------------------------------------------------
void CResourceMap::ClearDirty(ResID id)
{
    ASSERT(mResources->count(id) == 1);

    SResourceData& data = mResources->operator[](id);

    data.dirty = false;
}


//---------------------------------------------------------------
//
// CResourceMap::SetResourceName
//
//---------------------------------------------------------------
void CResourceMap::SetResourceName(ResID id, const string& newName)
{
    ASSERT(mResources->count(id) == 1);

    SResourceData& data = mResources->operator[](id);
    if (data.name != newName) {
        SResourceMapMessage mesg(this, id, kSetResourceName);

        data.name = newName;
        data.dirty = true;

        mesg.newRsrc.name = newName;
        this->Broadcast(mesg);
    }
}


//---------------------------------------------------------------
//
// CResourceMap::SetResourceData
//
//---------------------------------------------------------------
void CResourceMap::SetResourceData(ResID id, const THandle& newHand)
{
    ASSERT(mResources->count(id) == 1);

    SResourceData& data = mResources->operator[](id);

    if (newHand != data.hand) {

        // Do this the hard way to avoid invalidating objects that have
        // a copy of data.hand
        long bytes = newHand.GetSize();
        data.hand.SetSize(bytes);
        BlockMoveData(newHand.GetUnsafePtr(), data.hand.GetUnsafePtr(), bytes);

        data.dirty = true;

        this->Broadcast(SResourceMapMessage(this, id, kSetResourceData));
    }
}


//---------------------------------------------------------------
//
// CResourceMap::SetResourceID
//
//---------------------------------------------------------------
void CResourceMap::SetResourceID(ResID oldID, ResID newID)
{
    ASSERT(mResources->count(oldID) == 1);

    if (oldID != newID) {
        ASSERT(mResources->count(newID) == 0);

        SResourceMapMessage mesg(this, oldID, kSetResourceID);

        string name  = this->GetResourceName(oldID);
        THandle data = this->GetResourceData(oldID);

        mResources->erase(oldID);
        mResources->insert(ResourceEntry(newID, SResourceData(data, name, true)));

        mesg.newRsrc.id = newID;
        this->Broadcast(mesg);
    }

    ASSERT(mResources->count(newID) == 1);
}


//---------------------------------------------------------------
//
// CResourceMap::AddResource ()
//
//---------------------------------------------------------------
ResID CResourceMap::AddResource()
{
    ResID id = this->GetLastResourceID() + 1;
    ASSERT(mResources->count(id) == 0);

    mResources->insert(ResourceEntry(id, SResourceData(THandle(), "", true)));

    this->Broadcast(SResourceMapMessage(this, id, kAddedResource));

    return id;
}


//---------------------------------------------------------------
//
// CResourceMap::AddResource (SResource)
//
//---------------------------------------------------------------
void CResourceMap::AddResource(const SResource& rsrc)
{
    ASSERT(mResources->count(rsrc.id) == 0);

    mResources->insert(ResourceEntry(rsrc.id, SResourceData(rsrc.data, rsrc.name, true)));

    this->Broadcast(SResourceMapMessage(this, rsrc.id, kAddedResource));
}


//---------------------------------------------------------------
//
// CResourceMap::DeleteResource
//
//---------------------------------------------------------------
void CResourceMap::DeleteResource(ResID id)
{
    ASSERT(mResources->count(id) == 1);

    SResourceMapMessage mesg(this, id, kDeletedResource);

    mResources->erase(id);

    this->Broadcast(mesg);
}


//---------------------------------------------------------------
//
// CResourceMap::HasResource
//
//---------------------------------------------------------------
bool CResourceMap::HasResource(ResID id) const
{
    return mResources->count(id) == 1;
}


//---------------------------------------------------------------
//
// CResourceMap::begin
//
//---------------------------------------------------------------
CResourceMap::const_iterator CResourceMap::begin() const
{
    return CResourceMap::const_iterator(mResources);
}


//---------------------------------------------------------------
//
// CResourceMap::end
//
//---------------------------------------------------------------
CResourceMap::const_iterator CResourceMap::end() const
{
    return CResourceMap::const_iterator(MapIterator(mResources, 0));
}